{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "<center>\n",
    "<img src=\"https://github.com/Yorko/mlcourse.ai/blob/master/img/ods_stickers.jpg?raw=true\" />\n",
    "    \n",
    "## [mlcourse.ai](https://mlcourse.ai) - Open Machine Learning Course\n",
    "Auteur: [Yury Kashnitsky](https://yorko.github.io) (@yorko). Édité par Anna Tarelina (@feuerengel), Mikhail Korshchikov (@ MS4) et [Ousmane Cissé](https://github.com/oussou-dev). Ce matériel est soumis aux termes et conditions de la licence [Creative Commons CC BY-NC-SA 4.0] (https://creativecommons.org/licenses/by-nc-sa/4.0/). L'utilisation gratuite est autorisée à des fins non commerciales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "# <center>Mission # 2. Automne 2019\n",
    "## <center> Partie 1. Les arbres de décision pour la classification et la régression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**Dans cette mission, nous allons découvrir le fonctionnement d'un arbre de décision dans une tâche de régression, puis construire et ajuster des arbres de décision de classification pour l'identification des maladies du cœur.**\n",
    "\n",
    "Avant d'entamer la mission, nous vous conseillons de consulter le matériel de cours correspondant:\n",
    " 1. [Classification, arbres-de-décision et k-plus-proches-voisins](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic03_decision_trees_kNN/topic3_decision_trees_kNN.ipynb?flush_cache=true), version interactive sur [Kaggle](https://www.kaggle.com/kashnitsky/topic-3-decision-trees-and-knn)\n",
    " 2. Ensembles:\n",
    "  - [Bagging](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic05_ensembles_random_forests/topic5_part1_bagging.ipynb?flush_cache=true), version interactive sur [Kaggle](https://www.kaggle.com/kashnitsky/topic-5-ensembles-part-1-bagging)\n",
    "  - [Forêt aléatoire](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic05_ensembles_random_forests/topic5_part2_random_forest.ipynb?flush_cache=true), version intercative sur [Kaggle](https://www.kaggle.com/kashnitsky/topic-5-ensembles-part-2-random-forest)\n",
    "  - [Feature Importance](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic05_ensembles_random_forests/topic5_part3_feature_importance.ipynb?flush_cache=true), version interactive sur [Kaggle](https://www.kaggle.com/kashnitsky/topic-5- ensembles-part-3-feature-importance)\n",
    " 3. - [Gradient boosting](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic10_boosting/topic10_gradient_boosting.ipynb?flush_cache=true), version interactive sur [Kaggle](https://www.kaggle.com/kashnitsky/topic-10-gradient-boosting)\n",
    "   - Régression logistique, forêt aléatoire et LightGBM dans le cadre de la compétition \"Kaggle Forest Cover Type Prediction\": [Kernel](https://www.kaggle.com/kashnitsky/topic-10-practice-with-logit-rf-and-lightgbm) \n",
    " 4. Vous pouvez également vous exercer avec des missions de démonstration, plus simples et déjà partagées avec des solutions:\n",
    "     - \"Decision trees with a toy task and the UCI Adult dataset\": [mission](https://www.kaggle.com/kashnitsky/a3-demo-decision-trees) + [solution](https://www.kaggle.com/kashnitsky/a3-demo-decision-trees-solution)\n",
    "     - \"Logistic Regression and Random Forest in the credit scoring problem\": [mission](https://www.kaggle.com/kashnitsky/assignment-5-logit-and-rf-for-credit-scoring) + [solution](https://www.kaggle.com/kashnitsky/a5-demo-logit-and-rf-for-credit-scoring-sol)\n",
    " 5. Il y a également 7 conférences vidéo sur les arbres, les forêts, la stimulation et leurs applications : [mlcourse.ai/lectures](https://mlcourse.ai/lectures)  \n",
    " \n",
    "\n",
    "### Votre travail consiste à:\n",
    " 1. écrire du code et effectuer des calculs dans les cellules ci-dessous\n",
    " 2. Choisir les réponses dans le [formulaire](https://docs.google.com/forms/d/1-xvxl0xVVvoDYIbcCxxpAc_ pjcWEpnLQ9kaKLHwXsA). Les solutions seront partagées uniquement avec ceux qui ont rempli ce formulaire\n",
    " \n",
    "### <center> Date limite pour A2 : le 6 octobre 2019 à 20h59 (heure de Londres)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import GridSearchCV, train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier, export_graphviz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 1. Arbres de décision pour la régression : un exemple basé sur un jeu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Considérons le problème de régression unidimensionnel suivant. Nous devons créer une fonction $\\large a(x)$ pour approximer la dépendance $\\large y = f(x)$ en utilisant le critère d'erreur quadratique moyen: $\\large \\min \\sum_i {(a(x_i) - f(x_i))}^2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(-2, 2, 7)\n",
    "y = X ** 3  # original dependecy\n",
    "\n",
    "plt.scatter(X, y)\n",
    "plt.xlabel(r\"$x$\")\n",
    "plt.ylabel(r\"$y$\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Faisons plusieurs étapes pour construire un arbre de décision. Dans le cas d'une tâche **de régression**, au moment de la prédiction, la \"feuille\" renvoie la valeur moyenne pour toutes les observations de cette \"feuille.  \n",
    "\n",
    "Commençons par un arbre de profondeur 0, c’est-à-dire toutes les observations placées dans une seule \"feuille\".\n",
    "\n",
    "<br>Vous devrez construire un arbre avec un seul nœud (également appelé **root**) contenant toutes les observations d'entraînement (instances).\n",
    "<br>Comment les prédictions de cet arbre vont-elles ressembler pour $x \\in [-2, 2]$? <br> Créez un tracé approprié en utilisant un stylo, du papier et Python si nécessaire (mais vous n'avez pas encore besoin de `sklearn`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**Premières divisions ou partitions.**\n",
    "<br>Divisons les données en fonction de la condition suivante $[x < 0]$. Il nous donne l’arbre de profondeur 1 à deux feuilles. Pour clarifier, pour toutes les instances avec $x \\geqslant 0$, l’arbre renverra une valeur, pour toutes les instances avec $x < 0$, il retournera une autre valeur. Créons un graphique similaire pour les prédictions de cet arbre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Dans l'algorithme d'arbre de décision, la caractéristique et le seuil de partitonnement choisis en fonction de certains critères. Le critère de régression couramment utilisé est basé sur la variance: $$\\large Q(X, y, j, t) = D(X, y) - \\dfrac{|X_l|}{|X|} D(X_l, y_l) - \\dfrac{|X_r|}{|X|} D(X_r, y_r),$$\n",
    "où $\\large X$ et $\\large y$ sont une matrice de caractéristiques et un vecteur cible (en conséquence) pour l'apprentissage d'instances dans un nœud actuel, $\\large X_l, y_l$ et $\\large X_r, y_r$ sont des divisions d'échantillons $\\large X, y$ en deux parties w.r.t. $\\large [x_j < t]$ (par $\\large j$-ème caractéristique et seuil $\\large t$), $\\large |X|$, $\\large |X_l|$, $\\large |X_r|$ (ou identique, $\\large |y|$, $\\large |y_l|$, $\\large |y_r|$) sont des tailles d'échantillons appropriés, et $\\large D(X, y)$ est une variance des réponses $\\large y$ pour toutes les instances de $\\large X$:\n",
    "$$\\large D(X, y) = \\dfrac{1}{|X|} \\sum_{j=1}^{|X|}(y_j – \\dfrac{1}{|X|}\\sum_{i = 1}^{|X|}y_i)^2$$\n",
    "Ici $\\large y_i = y(x_i)$ est la réponse pour l'instance $\\large x_i$. Les indices $\\large j$ et seuil $\\large t$ sont choisis pour maximiser la valeur du critère $\\large Q(X, y, j, t)$ pour chaque division.\n",
    "\n",
    "Dans notre cas 1D, il n'y a qu'une seule caractéristique, si bien que $\\large Q$ ne dépend que du seuil $\\large t$ et des données d'apprentissage $\\large X$ et $\\large y$. Désignons $\\large Q_{1d}(X, y, t)$, ce qui signifie que le critère ne dépend plus de l'indice de la caractéristique $\\large j$, c'est-à-dire dans le cas 1D $\\large j = 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_var_criterion(X, y, t):\n",
    "    pass\n",
    "    # You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Créez le tracé du critère $\\large Q_{1d}(X, y, t)$ en fonction de la valeur de seuil $t$ sur l'intervalle $\\large [-1.9, 1.9]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**<font color='red'>Question 1.</font> Quelle est la valeur de seuil la plus défavorable (pour effectuer une partition) en fonction du critère de variance?**\n",
    "\n",
    "<font color = 'red'> **Options de réponse:** </font>\n",
    "- -1,9\n",
    "- -1,3\n",
    "- 0\n",
    "- 1,3\n",
    "- 1,9\n",
    "\n",
    "*Pour les discussions, merci de vous en tenir à [ODS Slack](https://opendatascience.slack.com/), channel __#mlcourse_ai_news__, fil épinglé __#a2_part1_fall2019__*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Faisons ensuite la partition en chacun des noeuds feuilles.\n",
    "<br> Prenez votre arbre avec le premier seuil [$x<0$].\n",
    "<br> Maintenant, ajoutez une partition dans la branche de gauche (où la division précédente était $x < 0$) en utilisant le critère $[x < -1.5]$, dans la branche de droite (où la division précédente était $x \\geqslant 0$) avec le critère suivant $[x < 1.5]$.\n",
    "<br>Nous obtenons un arbre de profondeur 2 avec 7 nœuds et 4 feuilles. Créez un graphique de cet arbre pour les prédictions de $x \\in [-2, 2]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**<font color='red'>Question 2.</font> Les prédictions de l'arbre sont une fonction constante par morceaux, n'est-ce pas ? Combien de \"morceaux\" (segments horizontaux dans le tracé que vous venez de construire) existe-t-il dans l'intervalle [-2, 2]?**\n",
    "\n",
    "<font color = 'red'> **Options de réponse:** </font>\n",
    "- 2\n",
    "- 4\n",
    "- 6\n",
    "- 8\n",
    "\n",
    "*Pour les discussions, merci de vous en tenir à [ODS Slack](https://opendatascience.slack.com/), channel __#mlcourse_ai_news__, fil épinglé __#a2_part1_fall2019__*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 2. Construire un arbre de décision pour prédire les maladies cardiaques\n",
    "Lisons les données sur les maladies cardiaques. Le jeu de données peut être téléchargé à partir du référentiel de cours [ici](https://github.com/Yorko/mlcourse.ai/blob/master/data/mlbootcamp5_train.csv) en cliquant sur `Download` puis en sélectionnant l'option `Save As`. Si vous travaillez avec Git, alors le jeu de données est déjà présent dans `data/mlbootcamp5_train.csv`.\n",
    "\n",
    "**Problème**\n",
    "\n",
    "Prédisez la présence ou l'absence de maladie cardiovasculaire (CVD) à l'aide des résultats de l'examen du patient.\n",
    "\n",
    "**Description des données**\n",
    "\n",
    "Il existe 3 types de caractéristiques d'entrée:\n",
    "\n",
    "- *Objective*: information factuelle;\n",
    "- *Examination*: résultats de l'examen médical;\n",
    "- *Subjective*: informations données par le patient.\n",
    "\n",
    "| Feature | Variable Type | Variable      | Value Type |\n",
    "|---------|--------------|---------------|------------|\n",
    "| Age | Objective Feature | age | int (days) |\n",
    "| Height | Objective Feature | height | int (cm) |\n",
    "| Weight | Objective Feature | weight | float (kg) |\n",
    "| Gender | Objective Feature | gender | categorical code |\n",
    "| Systolic blood pressure | Examination Feature | ap_hi | int |\n",
    "| Diastolic blood pressure | Examination Feature | ap_lo | int |\n",
    "| Cholesterol | Examination Feature | cholesterol | 1: normal, 2: above normal, 3: well above normal |\n",
    "| Glucose | Examination Feature | gluc | 1: normal, 2: above normal, 3: well above normal |\n",
    "| Smoking | Subjective Feature | smoke | binary |\n",
    "| Alcohol intake | Subjective Feature | alco | binary |\n",
    "| Physical activity | Subjective Feature | active | binary |\n",
    "| Presence or absence of cardiovascular disease | Target Variable | cardio | binary |\n",
    "\n",
    "Toutes les valeurs du jeu de données ont été collectées au moment de l'examen médical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"../../data/mlbootcamp5_train.csv\", index_col=\"id\", sep=\";\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Transformer les caractéristiques :\n",
    "- crée \"age in years\" en divisant l'âge par 365,25 et en prenant le seuil ($\\lfloor{x}\\rfloor$ est le plus grand entier inférieur ou égal à $x$)\n",
    "- créer 3 caractéristiques binaires basées sur `cholesterol`.\n",
    "- créer 3 caractéristiques binaires basées sur `gluc`.\n",
    "<br> Caractéristiques binaires égales à 1, 2 ou 3. Cette méthode est appelée codage factice ou codage à chaud -One Hot Encoding- (OHE). Il est plus pratique d'utiliser `pandas.get_dummies`. Il n’est pas nécessaire d’utiliser les caractéristiques originales `cholestérol` et` gluc` après l’encodage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Divisez les données en parties d'entraînement et de test dans la proportion de 7/3 en utilisant `sklearn.model_selection.train_test_split` avec` random_state = 17`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here\n",
    "# X_train, X_valid, y_train, y_valid = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Entraînez un arbre de décision sur le jeu de données `(X _train, y_ train)` avec **max_depth égale à 3** et `random _state = 17`. Tracez cet arbre avec `sklearn.tree.export_graphviz` et Graphviz. Nous devons mentionner ici que `sklearn` ne dessine pas seul les arbres de décision, mais est capable de générer un arbre au format `.dot` qui peut être utilisé par Graphviz pour la visualisation.\n",
    "\n",
    "Comment tracer un arbre de décision, alternatives:\n",
    " 1. Installez vous-même Graphviz et pydotpus (voir ci-dessous)\n",
    " 2. Utilisez notre image docker avec tous les paquets nécessaires déjà installés\n",
    " 3. Moyen facile: exécutez `print(dot _data.getvalue())` avec `dot_data` défini ci-dessous (vous pouvez le faire sans pydotplus et Graphviz), allez à http://www.webgraphviz.com, collez la chaîne de caractère de code graphique (digraph Tree {...) et générez une belle image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Il y a peut-être des problèmes avec graphviz pour les utilisateurs Windows.\n",
    "L'erreur est \"GraphViz's executables not found\".\n",
    "<br>Pour résoudre ce problème - installez Graphviz à partir d'[ici](https://graphviz.gitlab.io/_pages/Download/Download_ windows.html).\n",
    "<br>Puis ajouter graphviz path à votre variable système PATH. Vous pouvez le faire manuellement, mais n'oubliez pas de redémarrer\n",
    "<br>Ou juste exécuter ce code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "path_to_graphviz = \"\"  # your path to graphviz (C:\\\\Program Files (x86)\\\\Graphviz2.38\\\\bin\\\\ for example)\n",
    "os.environ[\"PATH\"] += os.pathsep + path_to_graphviz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Regardez comment les arbres sont visualisés dans la [3ème partie](https://nbviewer.jupyter.org/github/Yorko/mlcourse_open/blob/master/jupyter_english/topic03_decision_trees_kNN/topic3_decision_trees_kNN.ipynb?flush_cache=true) du matériel de cours."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**<font color='red'>Question 3.</font> Quelles sont les 3 caractéristiques utilisées pour effectuer des prédictions dans l'arbre de décision créé?**\n",
    "\n",
    "<font color = 'red'> **Options de réponse:** </font>\n",
    "- age, ap_lo, chol=1\n",
    "- age, ap_hi, chol=3\n",
    "- smoke, age, gender\n",
    "- alco, weight, gluc=3\n",
    "\n",
    "*Pour les discussions, merci de vous en tenir à [ODS Slack](https://opendatascience.slack.com/), channel __#mlcourse_ai_news__, fil épinglé __ #a2_part1_fall2019__*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Faites des prédictions pour les données de validation `(X_valid, y_valid)` avec l'arbre de décision formé. Calculer la précision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Définissez la profondeur (depth) de l’arbre à l’aide de la validation croisée sur le jeu de données `(X _train, y_ train)` afin d’améliorer la qualité du modèle. Utilisez `GridSearchCV` avec 5 folds. Fixez `random_state = 17` et changez` max_depth` de 2 à 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_params = {\"max_depth\": list(range(2, 11))}\n",
    "\n",
    "tree_grid = GridSearchCV  # You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Tracez le graphique pour montrer comment la précision moyenne change par rapport à la valeur `max_depth` lors de la validation croisée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Affichez la meilleure valeur de `max_depth` où la valeur moyenne de la métrique de qualité de validation croisée atteint son maximum. Calculez également la précision des données de test. Cela peut être fait avec l'instance entraînée de la classe `GridSearchCV`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Calculez l'effet de `GridSearchCV`: vérifiez l'expression (acc2-acc1)/acc1 * 100%, où acc1 et acc2 sont des précisions sur les données de test avant et après le réglage de max_depth avec GridSearchCV, respectivement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "**<font color='red'>Question 4.</font> Choisissez toutes les instructions correctes.**\n",
    "\n",
    "<font color = 'red'> **Options de réponse:** </font>\n",
    "\n",
    "- Il existe un maximum local de précision sur la courbe de validation construite\n",
    "- `GridSearchCV` a augmenté la précision sur les données de test de **plus** de 1%\n",
    "- Il y a **pas** de maximum de précision local sur la courbe de validation construite\n",
    "- `GridSearchCV` a augmenté la précision sur les données de test de **moins** que 1%\n",
    "\n",
    "*Pour les discussions, merci de vous en tenir à [ODS Slack](https://opendatascience.slack.com/), channel __#mlcourse_ai_news__, fil épinglé __#a2_part1_fall2019__*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Consultez le tableau SCORE pour évaluer le risque de maladie cardiovasculaire mortelle sur dix ans en Europe. [source](https://academic.oup.com/eurheartj/article/24/11/987/427645).\n",
    "\n",
    "<img src='https://github.com/Yorko/mlcourse.ai/blob/master/img/SCORE2007-eng.png?raw=true' width=70%>\n",
    "\n",
    "Créons de nouvelles caractéristiques en fonction de cette image:\n",
    "- $age \\in [40,50), age \\in [50,55), age \\in [55,60), age \\in [60,65) $ (4 caractéristiques)\n",
    "- systolic blood pressure (tension artérielle systolique) : $ap\\_hi \\in [120,140), ap\\_hi \\in [140,160), ap\\_hi \\in [160,180),$ (3 caractéristiques)\n",
    "\n",
    "Si les valeurs d'âge ou de pression artérielle ne tombent dans aucun des intervalles, toutes les caractéristiques binaires seront égales à zéro.\n",
    "\n",
    "<br>Ajout d'une caractéristique ``smoke``.\n",
    "<br>Build les caractéristiques ``cholesterol`` et ``gender``. Transformer le ``cholestérol`` en 3 fonctions binaires en fonction de ses 3 valeurs uniques (``cholestérol`` = 1, ``cholestérol`` = 2 et ``cholestérol`` = 3). Transformez le ``sexe`` de 1 et 2 en 0 et 1. Il vaut mieux le renommer en ``male`` (0 - woman, 1 - man). En général, cela se fait généralement avec ``sklearn.preprocessing.LabelEncoder`` mais ici, dans le cas de 2 valeurs uniques, ce n'est pas nécessaire.\n",
    "\n",
    "Enfin, l'arbre de décision est construit à l'aide de ces 12 caractéristiques binaires (à l'exclusion de toutes les caractéristiques d'origine dont nous disposions avant cette partie ingénierie des caractéristiques).\n",
    "\n",
    "Créez un arbre de décision avec la limitation `max_depth = 3` et entraînez-le sur l'ensemble des données d'entraînement. Utilisez la classe `DecisionTreeClassifier` avec` random_ state = 17` fixe, mais tous les autres arguments (à l'exception de `max_depth` et` random_state`) doivent être conservés avec leurs valeurs par défaut.\n",
    "\n",
    "**<font color='red'>Question 5.</font> Quelle caractéristique binaire est la plus importante pour la détection des maladies cardiaques (c’est-à-dire celle est placée à la racine (root) de l’arbre)?**\n",
    "\n",
    "<font color = 'red'> **Options de réponse:** </font>\n",
    "\n",
    "- Systolic blood pressure from 160 to 180 (mmHg)\n",
    "- Cholesterol level == 3\n",
    "- Systolic blood pressure from 140 to 160 (mmHg)\n",
    "- Age from 50 to 55 (years)\n",
    "- Smokes / doesn't smoke\n",
    "- Age from 60 to 65 (years)\n",
    "\n",
    "*Pour les discussions, merci de vous en tenir à [ODS Slack](https://opendatascience.slack.com/), channel __#mlcourse_ai_news__, fil épinglé __#a2_part1_fall2019_*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-27T18:33:43.204994Z",
     "start_time": "2019-09-27T18:33:43.198713Z"
    }
   },
   "outputs": [],
   "source": [
    "# You code here"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  },
  "name": "lesson4_part2_Decision_trees.ipynb",
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
